package com.ruoyi.psi.base.product.service;

import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.psi.base.cost.domain.ProductionCostDto;
import com.ruoyi.psi.base.cost.mapper.ProductionCostMapper;
import com.ruoyi.psi.base.product.domain.*;
import com.ruoyi.psi.base.product.mapper.ProductMapper;
import com.ruoyi.psi.base.warehouse.domain.WarehouseCond;
import com.ruoyi.psi.base.warehouse.service.IWarehouseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 产品
 * 业务层处理
 */
@Service
public class ProductServiceImpl implements IProductService{
    @Autowired
    private ProductMapper productMapper;
    @Autowired
    private ProductionCostMapper productionCostMapper;
    @Autowired
    private IWarehouseService warehouseService;

    /**
     * 根据条件查询产品
     * @param cond 条件
     * @return 产品集合
     */
    @Override
    public List<ProductDto> selectProductList(ProductCond cond) {
        List<ProductDto> productDtos = productMapper.selectProductList(cond);
        Map<String, Double> map = warehouseService.selectProductNumber(new WarehouseCond());
        for (ProductDto s : productDtos) {
            // 产品的库存数从仓库中查询
//            s.setProduceNumber(warehouseService.selectProductNumber(s.getProduceId()));
            s.setProduceNumber(map.get(s.getProduceId()));
        }
        return productDtos;
    }

    /**
     * 根据id查询产品
     * @param produceId 产品编号
     * @return 产品
     */
    @Override
    public ProductDto selectProductById(String produceId) {
        ProductDto product = productMapper.selectProductById(produceId);
//        product.setProduceNumber(warehouseService.selectProductNumber(product.getProduceId()));
        Map<String, Double> map = warehouseService.selectProductNumber(new WarehouseCond());
        product.setProduceNumber(map.get(product.getProduceId()));
        return product;
    }

    /**
     * 新增产品
     * @param product 产品信息
     * @return 结果
     */
    @Override
    public int insertProduct(ProductDomain product) {
        if (StringUtils.isNotNull(productMapper.selectProductById(product.getProduceId()))){
            //存在
            return 0;
        }
        return productMapper.insertProduct(product);
    }

    /**
     * 修改产品数据
     * @param product 产品信息
     * @return 结果
     */
    @Override
    public int updateProduct(ProductDomain product) {
        if (!StringUtils.isNotNull(productMapper.selectProductById(product.getProduceId()))){
            //存在
            return 0;
        }
        return productMapper.updateProduct(product);
    }

    /**
     * 删除功能
     * 更新对应产品删除标志
     * @param product 产品信息
     * @return
     */
    @Override
    public int updateProductDeleteFlag(ProductDomain product) {
        return productMapper.updateProductDeleteFlag(product);
    }

    /**
     * 查询所有产品的利润
     * @return
     */
    @Override
    public List<ProductionProfit> selectProductProfit(ProductCond cond) {
        List<ProductionProfit> productionProfitList = new ArrayList<>();
        // 查询所有产品信息
        List<ProductDto> productDtos = productMapper.selectAllProduct(cond);
//            System.out.println("产品信息" + baseProduces);
        for (int i = 0; i < productDtos.size(); i++) {
            ProductionProfit productionProfit = new ProductionProfit(); //产品利润对象
            String produceId = productDtos.get(i).getProduceId();
            productionProfit.setProduceId(produceId); //产品编号
            productionProfit.setProduceName(productDtos.get(i).getProduceName()); //产品名称
            productionProfit.setBaseCategoryName(productDtos.get(i).getBaseCategoryName()); //类别名称
            productionProfit.setBaseUnit(productDtos.get(i).getBaseUnit()); //计量单位名称
            productionProfit.setProduceSpecs(productDtos.get(i).getProduceSpecs()); //产品规格
            productionProfit.setProduceBrand(productDtos.get(i).getProduceBrand()); //产品品牌
            //计算利润
            ProductionCostDto productionCostDto = productionCostMapper.selectProductionCostById(produceId);
//                System.out.println("该产品的成本数据" + productionCostDto);
            if (StringUtils.isNotNull(productionCostDto)) {
                //利润 = 销售单价 - 该产品成本
                Double profit = productDtos.get(i).getProduceSalePrice() - productionCostDto.getTotalCost();
                productionProfit.setProfit(profit);
            } else {
                // 利润 = 售价
                Double profit = productDtos.get(i).getProduceSalePrice();
                productionProfit.setProfit(profit);
            }
            productionProfitList.add(productionProfit); //将当前产品利润对象添加到集合中
        }
        return productionProfitList;
    }

    /**
     * 查询各自不同种类产品的库存
     * @return
     */
    @Override
    public List<ProductInventory> selectProductInventoryByCategoryId(String baseCategoryName) {
        List<ProductInventory> productInventoryList = new ArrayList<>(); //返回类
        List<ProductStorage> productStorages = productMapper.selectProductStorageByCategoryId(baseCategoryName); //入库数量
//        System.out.println("入库情况" + productStorages);
        List<ProductDelivery> productDeliveries = productMapper.selectProductDeliveryByCategoryId(baseCategoryName); //出库数量
//        System.out.println("出库情况" + productDeliveries);
        for (ProductStorage s : productStorages) {
            ProductInventory productInventory = new ProductInventory(); //对象
            productInventory.setMont(s.getMont()); //设置月份
            double inventoryQuantities = s.getStorageQuantities(); //库存数先默认等于入库数
            for (ProductDelivery d : productDeliveries) {
                if (s.getMont().equals(d.getMont())) {
                    // 出入库月份相等，说明该月份有出库数量
                    inventoryQuantities -= d.getDeliveryQuantities();
                }
            }
            productInventory.setInventoryQuantities(inventoryQuantities); //设置库存数
            productInventoryList.add(productInventory);
        }
        return productInventoryList;
    }
}
